package com.zs.basic.runoob

/**
 *
 * @description
 * @author madison
 * @date 2021/6/3 22:50
 *
 */
class Example // 从 Any 隐式继承
//Any 默认提供了三个函数：
//equals()
//hashCode()
//toString()

open class Base1(p: Int)           // 定义基类

class Derived1(p: Int) : Base1(p)

open class Person4(var name: String, var age: Int) //基类
class Student(name: String, age: Int, var no: String, var score: Int) : Person4(name, age)

/**用户基类**/
open class Person5(name: String) {
    /**次级构造函数**/
    constructor(name: String, age: Int) : this(name) {
        //初始化
        println("-------基类次级构造函数---------")
    }
}

/**子类继承 Person 类**/
class Student1 : Person5 {
    /**次级构造函数**/
    constructor(name: String, age: Int, no: String, score: Int) : super(name, age) {
        println("-------继承类次级构造函数---------")
        println("学生名： ${name}")
        println("年龄： ${age}")
        println("学生号： ${no}")
        println("成绩： ${score}")
    }
}

/**重写**/
open class Person6 {
    open fun study() {
        println("我毕业了")
    }
}

class Student2 : Person6() {
    override fun study() {
        println("我在读大学")
    }
}

/**如果有多个相同的方法（继承或者实现自其他类，如A、B类），
 * 则必须要重写该方法，使用super范型去选择性地调用父类的实现。**/
open class A {
    open fun f() {
        print("A")
    }

    fun a() {
        print("a")
    }
}

interface B {
    fun f() {
        print("B")
    } //接口的成员变量默认是 open 的

    fun b() {
        print("b")
    }
}

class C : A(), B {
    override fun f() {
        super<A>.f()//调用 A.f()
        super<B>.f()//调用 B.f()
    }
}

/**你可以用一个var属性重写一个val属性，但是反过来不行。
 * 因为val属性本身定义了getter方法，重写为var属性会在衍生类中额外声明一个setter方法**/
interface Foo {
    val count: Int
}

class Bar1(override val count: Int) : Foo

class Bar2 : Foo {
    override var count: Int = 0
}

fun main() {
    val s = Student("Runbbo", 18, "S123456", 89)
    println("学生名： ${s.name}")
    println("年龄： ${s.age}")
    println("学生号： ${s.no}")
    println("成绩： ${s.score}")

    val s1 = Student1("Runbbo", 18, "S123456", 89)
    var s2 = Student2()
    s2.study()

    val c = C()
    c.f()
}